package lanQiaoBei.基础算法.离散化;

import java.util.*;
import java.io.*;
import java.util.stream.*;

import org.xml.sax.HandlerBase;

/*
  离散化（整数有序）的核心思想：数据范围很大 但数据数量不多 可以考虑将数据离散化处理
* 以“区间和”题目为例
  假设有一个无限长的数轴，数轴上的每个坐标的数都是0
  现在，我们进行n次操作，每次操作在x的上加上c
  接下来进行m次询问，每次询问包含两个整数l和r，你需要求出l到r区间的所有和
  输入格式：
  n,m（-10^5~+10^5）
  n行 x(-无穷~+无穷),c
  m行 l,r（-无穷~+无穷）
  输出格式：
  m行 区间和
3 3
1 2
3 6
7 5
1 3
4 6
7 8

输出：
8
0
5
* */
public class P1 {
	static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static final int N=(int)3e5+10;
	static int a[]=new int[N],n,m;
	static Pair operator[]=new Pair[N],query[]=new Pair[N];
	static List<Integer> collect=null;
	static class Pair{
	       int k,v;
		   Pair(int k,int v){
			   this.k=k;
			   this.v=v;
		   }
	}
	static int mapping(int x){
		   int l=0,r=collect.size()-1;
		   while(l<r){
			    int mid=l+r+1>>1;
				if(collect.get(mid)<=x)
					l=mid;
				else r=mid-1;
		   }
		   return l+1;
	}
	public static void main(String[] ss) throws IOException {
		   ss=br.readLine().split(" ");
		   n=Integer.parseInt(ss[0]);m=Integer.parseInt(ss[1]);
		   HashSet<Integer>set=new HashSet<>();//去重
		   for(int i=0;i<n;i++){
			   ss=br.readLine().split(" ");
			   int x=Integer.parseInt(ss[0]),c=Integer.parseInt(ss[1]);
			   operator[i]=new Pair(x,c);
			   set.add(x);//将数轴上可能用到的数加入集合
		   }
		   for(int i=0;i<m;i++){
			   ss=br.readLine().split(" ");
			   int l=Integer.parseInt(ss[0]),r=Integer.parseInt(ss[1]);
			   query[i]=new Pair(l,r);
			   set.add(l);//将数轴上可能用到的数加入集合
			   set.add(r);//将数轴上可能用到的数加入集合
		   }
		   collect = set.stream().sorted((o1, o2) -> o1 - o2).collect(Collectors.toList());//排序
		   for(int i=0;i<n;i++){//将数轴的那些位置加上c
			   int index=mapping(operator[i].k);
			   a[index]+=operator[i].v;
		   }
		   for(int i=1;i<N;i++)//求前缀和
			   a[i]=a[i-1]+a[i];
		   for(int i=0;i<m;i++)//求lx-rx区间和
			   System.out.println(a[mapping(query[i].v)]-a[mapping(query[i].k)-1]);
	}
}